// models/SysUser.js
const mongoose = require('mongoose');
const { Schema } = mongoose;

/**
 * 系统用户表 - 对应 MySQL sys_user 表
 */
const sysUserSchema = new Schema({
  // 用户ID - 对应MySQL的user_id
  userId: {
    type: Number,
    required: true,
    unique: true,
    index: true,
    comment: '用户ID'
  },
  
  // 部门ID - 对应MySQL的dept_id
  deptId: {
    type: Number,
    default: null,
    index: true,
    comment: '部门ID'
  },
  
  // 用户账号 - 对应MySQL的user_name
  userName: {
    type: String,
    required: [true, '用户账号不能为空'],
    trim: true,
    minlength: [2, '用户账号至少2个字符'],
    maxlength: [30, '用户账号不能超过30个字符'],
    match: [/^[a-zA-Z0-9_]+$/, '用户账号只能包含字母、数字和下划线'],
    index: true,
    comment: '用户账号'
  },
  
  // 用户昵称 - 对应MySQL的nick_name
  nickName: {
    type: String,
    required: [true, '用户昵称不能为空'],
    trim: true,
    minlength: [1, '用户昵称至少1个字符'],
    maxlength: [30, '用户昵称不能超过30个字符'],
    comment: '用户昵称'
  },
  
  // 用户类型 - 对应MySQL的user_type
  userType: {
    type: String,
    enum: {
      values: ['00', '01', '02'],
      message: '用户类型必须是 00(系统用户)、01(其他用户) 或 02(第三方用户)'
    },
    default: '00',
    comment: '用户类型（00系统用户）'
  },
  
  // 用户邮箱 - 对应MySQL的email
  email: {
    type: String,
    default: '',
    trim: true,
    lowercase: true,
    validate: {
      validator: function(email) {
        if (email === '') return true; // 允许空字符串
        return /^\w+([.-]?\w+)*@\w+([.-]?\w+)*(\.\w{2,3})+$/.test(email);
      },
      message: '请输入有效的邮箱地址'
    },
    comment: '用户邮箱'
  },
  
  // 手机号码 - 对应MySQL的phonenumber
  phoneNumber: {
    type: String,
    default: '',
    trim: true,
    match: [/^$|^1[3-9]\d{9}$/, '请输入有效的手机号码'],
    comment: '手机号码'
  },
  
  // 用户性别 - 对应MySQL的sex
  sex: {
    type: String,
    enum: {
      values: ['0', '1', '2'],
      message: '用户性别必须是 0(男)、1(女) 或 2(未知)'
    },
    default: '0',
    comment: '用户性别（0男 1女 2未知）'
  },
  
  // 头像地址 - 对应MySQL的avatar
  avatar: {
    type: String,
    default: '',
    comment: '头像地址'
  },
  
  // 密码 - 对应MySQL的password
  password: {
    type: String,
    default: '',
    select: false, // 查询时默认不返回密码字段
    comment: '密码'
  },
  
  // 帐号状态 - 对应MySQL的status
  status: {
    type: String,
    enum: {
      values: ['0', '1'],
      message: '帐号状态必须是 0(正常) 或 1(停用)'
    },
    default: '0',
    index: true,
    comment: '帐号状态（0正常 1停用）'
  },
  
  // 删除标志 - 对应MySQL的del_flag
  delFlag: {
    type: String,
    enum: {
      values: ['0', '2'],
      message: '删除标志必须是 0(存在) 或 2(删除)'
    },
    default: '0',
    index: true,
    comment: '删除标志（0代表存在 2代表删除）'
  },
  
  // 最后登录IP - 对应MySQL的login_ip
  loginIp: {
    type: String,
    default: '',
    comment: '最后登录IP'
  },
  
  // 最后登录时间 - 对应MySQL的login_date
  loginDate: {
    type: Date,
    default: null,
    comment: '最后登录时间'
  },
  
  // 创建者 - 对应MySQL的create_by
  createBy: {
    type: String,
    default: '',
    comment: '创建者'
  },
  
  // 创建时间 - 对应MySQL的create_time
  createTime: {
    type: Date,
    default: Date.now,
    comment: '创建时间'
  },
  
  // 更新者 - 对应MySQL的update_by
  updateBy: {
    type: String,
    default: '',
    comment: '更新者'
  },
  
  // 更新时间 - 对应MySQL的update_time
  updateTime: {
    type: Date,
    default: Date.now,
    comment: '更新时间'
  },
  
  // 备注 - 对应MySQL的remark
  remark: {
    type: String,
    default: null,
    maxlength: [500, '备注不能超过500个字符'],
    comment: '备注'
  }
}, {
  // Schema 选项
  timestamps: false, // 不使用 Mongoose 的自动时间戳，使用自定义字段
  collection: 'sys_users', // 集合名称
  toJSON: { virtuals: true },
  toObject: { virtuals: true }
});

// 创建复合索引
sysUserSchema.index({ delFlag: 1, status: 1 });
sysUserSchema.index({ userName: 1, delFlag: 1 });
sysUserSchema.index({ createTime: -1 });

// 虚拟字段
sysUserSchema.virtual('isActive').get(function() {
  return this.status === '0' && this.delFlag === '0';
});

sysUserSchema.virtual('isDeleted').get(function() {
  return this.delFlag === '2';
});

sysUserSchema.virtual('sexText').get(function() {
  const sexMap = { '0': '男', '1': '女', '2': '未知' };
  return sexMap[this.sex] || '未知';
});

sysUserSchema.virtual('statusText').get(function() {
  const statusMap = { '0': '正常', '1': '停用' };
  return statusMap[this.status] || '未知';
});

// 实例方法
sysUserSchema.methods = {
  // 验证密码
  validatePassword: function(password) {
    // 实际项目中应该使用 bcrypt 等加密库
    // 这里简单演示，实际应该使用: return bcrypt.compareSync(password, this.password);
    return this.password === password;
  },
  
  // 获取用户公开信息（排除敏感字段）
  toPublicJSON: function() {
    const user = this.toObject();
    delete user.password;
    delete user.__v;
    return user;
  },
  
  // 记录登录信息
  recordLogin: function(ip) {
    this.loginIp = ip;
    this.loginDate = new Date();
    return this.save();
  },
  
  // 启用/禁用用户
  toggleStatus: function() {
    this.status = this.status === '0' ? '1' : '0';
    this.updateTime = new Date();
    return this.save();
  },
  
  // 软删除用户
  softDelete: function() {
    this.delFlag = '2';
    this.updateTime = new Date();
    return this.save();
  },
  
  // 恢复用户
  restore: function() {
    this.delFlag = '0';
    this.updateTime = new Date();
    return this.save();
  }
};

// 静态方法
sysUserSchema.statics = {
  // 根据用户名查找用户（包含密码）
  findByUserNameWithPassword: function(userName) {
    return this.findOne({ 
      userName: new RegExp(`^${userName}$`, 'i'),
      delFlag: '0'
    }).select('+password');
  },
  
  // 根据用户名查找用户
  findByUserName: function(userName) {
    return this.findOne({ 
      userName: new RegExp(`^${userName}$`, 'i'),
      delFlag: '0'
    });
  },
  
  // 根据邮箱查找用户
  findByEmail: function(email) {
    return this.findOne({ 
      email: email.toLowerCase(),
      delFlag: '0'
    });
  },
  
  // 根据手机号查找用户
  findByPhoneNumber: function(phoneNumber) {
    return this.findOne({ 
      phoneNumber,
      delFlag: '0'
    });
  },
  
  // 获取所有有效用户
  findActiveUsers: function() {
    return this.find({ 
      delFlag: '0',
      status: '0'
    }).sort({ createTime: -1 });
  },
  
  // 分页查询用户
  findUsersPaginated: function(options = {}) {
    const {
      page = 1,
      limit = 10,
      userName = '',
      nickName = '',
      status = '',
      deptId = null
    } = options;
    
    const skip = (page - 1) * limit;
    const query = { delFlag: '0' };
    
    // 构建查询条件
    if (userName) {
      query.userName = { $regex: userName, $options: 'i' };
    }
    
    if (nickName) {
      query.nickName = { $regex: nickName, $options: 'i' };
    }
    
    if (status) {
      query.status = status;
    }
    
    if (deptId) {
      query.deptId = deptId;
    }
    
    return Promise.all([
      this.find(query)
        .select('-password')
        .skip(skip)
        .limit(limit)
        .sort({ userId: 1 }),
      this.countDocuments(query)
    ]).then(([users, total]) => ({
      users,
      pagination: {
        page: parseInt(page),
        limit: parseInt(limit),
        total,
        pages: Math.ceil(total / limit)
      }
    }));
  },
  
  // 用户统计
  getUserStats: function() {
    return this.aggregate([
      {
        $match: { delFlag: '0' }
      },
      {
        $group: {
          _id: '$status',
          count: { $sum: 1 },
          deptCount: { $addToSet: '$deptId' }
        }
      },
      {
        $project: {
          status: '$_id',
          count: 1,
          deptCount: { $size: '$deptCount' },
          _id: 0
        }
      }
    ]);
  },
  
  // 检查用户名是否已存在
  isUserNameExists: function(userName, excludeUserId = null) {
    const query = { 
      userName: new RegExp(`^${userName}$`, 'i'),
      delFlag: '0'
    };
    
    if (excludeUserId) {
      query.userId = { $ne: excludeUserId };
    }
    
    return this.findOne(query);
  },
  
  // 检查邮箱是否已存在
  isEmailExists: function(email, excludeUserId = null) {
    const query = { 
      email: email.toLowerCase(),
      delFlag: '0'
    };
    
    if (excludeUserId) {
      query.userId = { $ne: excludeUserId };
    }
    
    return this.findOne(query);
  },
  
  // 检查手机号是否已存在
  isPhoneNumberExists: function(phoneNumber, excludeUserId = null) {
    const query = { 
      phoneNumber,
      delFlag: '0'
    };
    
    if (excludeUserId) {
      query.userId = { $ne: excludeUserId };
    }
    
    return this.findOne(query);
  }
};

// 查询助手
sysUserSchema.query = {
  // 按状态筛选
  byStatus: function(status) {
    return this.where('status').equals(status);
  },
  
  // 按部门筛选
  byDept: function(deptId) {
    return this.where('deptId').equals(deptId);
  },
  
  // 按删除状态筛选
  byDelFlag: function(delFlag = '0') {
    return this.where('delFlag').equals(delFlag);
  },
  
  // 按用户类型筛选
  byUserType: function(userType) {
    return this.where('userType').equals(userType);
  },
  
  // 搜索用户名或昵称
  searchByName: function(keyword) {
    return this.where({
      $or: [
        { userName: { $regex: keyword, $options: 'i' } },
        { nickName: { $regex: keyword, $options: 'i' } }
      ]
    });
  }
};

// 中间件
sysUserSchema.pre('save', function(next) {
  // 更新更新时间
  this.updateTime = new Date();
  
  // 用户名转小写
  if (this.isModified('userName')) {
    this.userName = this.userName.toLowerCase();
  }
  
  // 邮箱转小写
  if (this.isModified('email')) {
    this.email = this.email.toLowerCase();
  }
  
  next();
});

// 创建模型
const User = mongoose.model('User', sysUserSchema);

module.exports = User;